/*  PadNull
 *  Copyright (C) 2004-2010  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
 *  ation, either version 3 of the License, or (at your option) any later version.
 *
 *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 *  PURPOSE.  See the GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along with PCSX2.
 *  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <string>
using namespace std;
#include "svnrev.h"
#include "Pad.h"

static const u8 version = PS2E_PAD_VERSION;
static const u8 revision = 0;
static const u8 build = 1; // increase that with each version

#ifdef _MSC_VER
#define snprintf sprintf_s
#endif
#ifdef BUILTIN_PAD_PLUGIN
extern std::string s_strIniPath;
extern std::string s_strLogPath;
#else
static char libraryName[256];
string s_strIniPath = "inis";
string s_strLogPath = "logs";
#endif

FILE *padLog;
Config conf;
keyEvent event;
static keyEvent s_event;
#ifndef BUILTIN_PAD_PLUGIN
EXPORT_C_(u32)
PS2EgetLibType()
{
    return PS2E_LT_PAD;
}

EXPORT_C_(const char *)
PS2EgetLibName()
{
    snprintf(libraryName, 255, "Padnull Driver %lld%s", SVN_REV, SVN_MODS ? "m" : "");
    return libraryName;
}

EXPORT_C_(u32)
PS2EgetLibVersion2(u32 type)
{
    return (version << 16) | (revision << 8) | build;
}

void __Log(const char *fmt, ...)
{
    va_list list;

    if (padLog == NULL)
        return;
    va_start(list, fmt);
    vfprintf(padLog, fmt, list);
    va_end(list);
}

void __LogToConsole(const char *fmt, ...)
{
    va_list list;

    va_start(list, fmt);

    if (padLog != NULL)
        vfprintf(padLog, fmt, list);

    printf("PadNull: ");
    vprintf(fmt, list);
    va_end(list);
}
#endif
EXPORT_C_(void)
PADsetSettingsDir(const char *dir)
{
    s_strIniPath = (dir == NULL) ? "inis" : dir;
}

bool OpenLog()
{
    bool result = true;
#ifdef PAD_LOG
    if (padLog)
        return result;

    const std::string LogFile(s_strLogPath + "/padnull.log");

    padLog = fopen(LogFile.c_str(), "w");
    if (padLog != NULL)
        setvbuf(padLog, NULL, _IONBF, 0);
    else {
        fprintf(stderr, "Can't create log file %s\n", LogFile.c_str());
        result = false;
    }
    PAD_LOG("PADinit\n");
#endif
    return result;
}

EXPORT_C_(void)
PADsetLogDir(const char *dir)
{
    // Get the path to the log directory.
    s_strLogPath = (dir == NULL) ? "logs" : dir;

    // Reload the log file after updated the path
    if (padLog) {
        fclose(padLog);
        padLog = NULL;
    }
    OpenLog();
}

EXPORT_C_(s32)
PADinit(u32 flags)
{
    PADLoadConfig();

    OpenLog();

    return 0;
}

EXPORT_C_(void)
PADshutdown()
{
#ifdef PAD_LOG
    if (padLog) {
        fclose(padLog);
        padLog = NULL;
    }
#endif
}

EXPORT_C_(s32)
PADopen(void *pDsp)
{
    memset(&event, 0, sizeof(event));

    return _PADOpen(pDsp);
}

EXPORT_C_(void)
PADclose()
{
    _PADClose();
}

// PADkeyEvent is called every vsync (return NULL if no event)
EXPORT_C_(keyEvent *)
PADkeyEvent()
{

    s_event = event;
    event.evt = 0;
    event.key = 0;

    return &s_event;
}

EXPORT_C_(u8)
PADstartPoll(int pad)
{
    return 0;
}

EXPORT_C_(u8)
PADpoll(u8 value)
{
    return 0;
}

// call to give a hint to the PAD plugin to query for the keyboard state. A
// good plugin will query the OS for keyboard state ONLY in this function.
// This function is necessary when multithreading because otherwise
// the PAD plugin can get into deadlocks with the thread that really owns
// the window (and input). Note that PADupdate can be called from a different
// thread than the other functions, so mutex or other multithreading primitives
// have to be added to maintain data integrity.
EXPORT_C_(u32)
PADquery()
// returns: 1 if supported pad1
//			2 if supported pad2
//			3 if both are supported
{
    return 3;
}

EXPORT_C_(void)
PADupdate(int pad)
{
    _PadUpdate(pad);
}

EXPORT_C_(void)
PADgsDriverInfo(GSdriverInfo *info)
{
}

EXPORT_C_(s32)
PADqueryMtap(u8 port)
{
   return 0;
}

EXPORT_C_(s32)
PADfreeze(int mode, freezeData *data)
{
    return 0;
}

EXPORT_C_(s32)
PADtest()
{
    return 0;
}

EXPORT_C_(s32)
PADsetSlot(u8 port, u8 slot)
{
    if (port > 2 || slot > 4) {
        return 0;
    }
    return 1;
}

#if defined(__unix__)
EXPORT_C_(void)
PADWriteEvent(keyEvent &evt)
{
}
#endif
